//拷贝对象__b中的属性 到a中， 覆盖相同的属性

window.lhp_deepcopy2=function(a,path,__b){
    if (typeof __b !== 'object' || __b === null ||path=='') {  
      //   console.log("???")
        return ;  
    }  
    __b=JSON.parse(JSON.stringify(__b));
    let path_lst=path.split(".");
    for(let i=0;i<path_lst.length-1;i++){a=a[path_lst[i]]}
    let stack=[]
    stack.push([[],__b])
   //  console.log("stack:",stack)
    while( stack.length){
        let new_stack=[]
        for (let i =0;i<stack.length;i++){
            let item=stack[i]
            let key=item[0],value=item[1]
            let temp_val=a
            let temp_b=__b
            if (key.length==0){
                let kkpath=path_lst[path_lst.length-1];
                if (kkpath in temp_val){
                    //为对象 则加入深度遍历队列 等待下一轮遍历
                    if(typeof temp_b === 'object'&&temp_b!=null&& temp_val[kkpath]!=null){for (
                     let k in temp_b){new_stack.push([ [...key, k],temp_b[k]])}}
                    //不为对象  则直接覆盖
                    else{
                  //   console.log('不拥有直接覆盖1',key,temp_b)
                        temp_val[kkpath]=temp_b}
                }
                //不拥有 则直接覆盖
                else{
                  //   console.log('不拥有直接覆盖2',key,temp_b)
                    //如果是数组 则直接插入
                    if (Array.isArray(temp_val)){
                        temp_val.push(temp_b)
                    }else{
                    //不是数组 就按照对象设置属性
                        temp_val[kkpath]=temp_b
                    }
                    
                }
            break}
            temp_val=temp_val[path_lst[path_lst.length-1]]
            for(let j =0;j<key.length;j++){temp_b=temp_b[key[j]]}
            for(let j =0;j<key.length-1;j++){temp_val=temp_val[key[j]]}
            
            //如果a 拥有b这个属性 判断是否为对象，从而进行深度遍历
            if (key[key.length-1] in temp_val){
               //  console.log("如果a拥有b这个属性",key[key.length-1])
                //为对象 则加入深度遍历队列 等待下一轮遍历
                if(typeof temp_b === 'object' &&temp_b !=null && temp_val[key[key.length-1]]!=null){
                  
                  // console.log("????")
                  for (let k in temp_b){
                    new_stack.push([ [...key, k],temp_b[k]])}}
                //不为对象  则直接覆盖
                else{
               //  console.log('不拥有直接覆盖3',key,temp_b)
                    temp_val[key[key.length-1]]=temp_b}
            }
            //不拥有 则直接覆盖
            else{
               //  console.log('不拥有直接覆盖4',key,temp_b)
                //如果是数组 则直接插入
                if (Array.isArray(temp_val)){
                    temp_val.push(temp_b)
                }else{
                //不是数组 就按照对象设置属性
                    temp_val[key[key.length-1]]=temp_b
                }
                
            }
            
        }
        stack=new_stack
    }

}
window.lhp_delete2=function(a,path){
    if (path=='') {  return ;     }  
    let path_lst=path.split(".");
    let last_idx=path_lst.length-1;
    for(let i=0;i<last_idx;i++){a=a[path_lst[i]]}
    delete a[path_lst[last_idx]]

}
// let a={1:{3:4,1:2,c:{}}},path="1.c.z",b={1:{1:3,5:6},2:4,d:undefined}
// lhp_deepcopy2(a,path,b)
// console.log("a:",a)

// a=[0,0,2,3,[1,2,3]],path="4.3",b=[1,2,3,4,[1,2,3,4,5]]
// lhp_deepcopy2(a,path,b)
// console.log("a:",a)
